{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div align=\"right\" style=\"text-align:right\"><a href=\"http://norvig.com\">Peter Norvig</a><br>March 2019</div>\n",
    "\n",
    "#  Dice Baseball Simulation\n",
    "\n",
    "The [538 Riddler for March 22, 2019](https://fivethirtyeight.com/features/can-you-turn-americas-pastime-into-a-game-of-yahtzee/) asks us to simulate baseball using probabilities from a 19th century dice game called *Our National Ball Game*. The Riddler description of the rules said \"*you can assume some standard baseball things*\" but left some things unspecified, so I [looked up](http://baseballgames.dreamhosters.com/BbDiceHome.htm) the original rules of *Our National Ball Game*, which, it turns out, contradict some of the \"*standard baseball things*\" assumed by 538:\n",
    "\n",
    "\n",
    "|RULES FOR PLAYING \"OUR NATIONAL BALL GAME\"|DICE ROLL OUTCOMES|\n",
    "|-----|-----|\n",
    "| ![](http://baseballgames.dreamhosters.com/bbOurNationalBallGameMcGillDelanyHoag86diE2.jpg) |  ![](http://baseballgames.dreamhosters.com/bbOurNationalBallGameMcGillDelanyHoag86ddE.jpg) |\n",
    "\n",
    "# Design Choices\n",
    "\n",
    "\n",
    "- To clarify: the dice roll `1,1` has probability 1/36, whereas `1,2` has probability 2/36, because it also represents `2,1`.\n",
    "- Exactly one thing happens to each batter. I'll call that an **event**.\n",
    "- The \"One Strike\" dice roll is not an event; it is only *part* of an event. From the probability of a \"One Strike\" dice roll, 7/36, I compute the probability of three strikes in a row, `(7/36)**3 == 0.00735`, and call that a strikeout event. \n",
    "- I'll represent events with the following 11 one letter **event codes**:\n",
    "  - `1`, `2`, `3`, `4`: one-, two-, three-, and four-base (home run) hits. Runners advance same number of bases.\n",
    "  - `B`: base on balls. Runners advance only if forced.\n",
    "  - `D`: double play. Batter and runner nearest home are out (according to rules); others advance one base.\n",
    "  - `E`: error. Batter reaches first and all runners advance one base.\n",
    "  - `F`, `K`, `f`: fly out, strikeout, foul out. Batter is out, runners do not advance.\n",
    "  - `S`: called \"out at first\" in rules, but actually a sacrifice. Batter is out, runners advance one base."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "event_names = {\n",
    "    '1': 'single',        '2': 'double',      '3': 'triple',    '4': 'home run',\n",
    "    'B': 'base on balls', 'D': 'double play', 'E': 'error',\n",
    "    'f': 'foul out',      'F': 'fly out',     'K': 'strikeout', 'S': 'out at first'}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#  Implementation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I'll define the function `inning` to simulate a half inning and return the number of runs scored.  Design choices for `inning`:\n",
    "\n",
    "- I'll keep track of runners with a set of occupied bases; `runners = {1, 3}` means runners on first and third.\n",
    "- I'll keep track of the number of `runs` and `outs`, and return`runs` when there are three `outs`.\n",
    "- Each event follows four steps. E.g., if `runners = {1, 3}` and the `event = 2` (a double), then:\n",
    "  1. The batter steps up to the plate. The plate is represented as base `0`, so now `runners = {0, 1, 3}`.\n",
    "  2. Check if the event causes runner(s) to be out, and if the inning is over. In this case, no.\n",
    "  3. Advance each runner according to `advance(r, e)`. In this case, `runners = {2, 3, 5}`.\n",
    "  4. Remove the runners who have `scored` and increment `runs` accordingly. In this case, runner `5` has scored, so we increment `runs` by 1 and end up with `runners = {2, 3}`.\n",
    "- I want `inning` to be easily **testable**: I want to say `assert 2 == inning('1Kf4F')`.\n",
    "- I also want `inning` to be capable of simulating many independent random innings.  So the interface is to accept an *iterable* of event codes. That could be a string, or it could be a generator as provided by `event_stream()`.\n",
    "- I want `inning` to be **loggable**: `inning(events, verbose=True)` should log each event.\n",
    "- `advance(r, e)` says that a runner advances `e` bases on an `e` base hit; one base on an error, sacrifice, or double play (for the runners who are not out); and one base on a base on balls only if forced.\n",
    "- A runner on base `r` is `forced` if all the lower-numbered bases have runners.\n",
    "- `ONBG` is defined as a generator of random events with the probabilities from \"**O**ur **N**ational **B**all **G**ame\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import random\n",
    "from statistics  import mean, stdev\n",
    "from collections import Counter\n",
    "from typing import List"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "def inning(events, verbose=True) -> int:\n",
    "    \"\"\"Simulate a half inning based on events, and return number of runs scored.\"\"\"\n",
    "    outs = runs = 0     # Inning starts with no outs and no runs,\n",
    "    runners = set()     # and with nobody on base\n",
    "    def out(r) -> int: runners.remove(r); return 1\n",
    "    def forced(r) -> bool: return all(b in runners for b in range(r))\n",
    "    def advance(r, e) -> int: \n",
    "        return int(e if e in '1234' else (e in 'ESD' or (e == 'B' and forced(r))))\n",
    "    for e in events:\n",
    "        if verbose: log(outs, runs, runners, e)\n",
    "        runners.add(batter)           # Batter steps up to the plate\n",
    "        if e in 'DSKfF':              \n",
    "            outs += out(batter)       # Batter is out\n",
    "            if e == 'D' and runners and outs < 3: \n",
    "                outs += out(max(runners)) # Double play: lead runner out\n",
    "        if outs == 3:                 # If inning is over: return runs scored\n",
    "            return runs \n",
    "        runners = {r + advance(r, e) for r in runners} # Runners advance\n",
    "        scored  = {r for r in runners if r >= 4}       # Calculate the runners who scored\n",
    "        runners = runners - scored                     # Remove runners who scored\n",
    "        runs   += len(scored)                          # Tally runs\n",
    "        \n",
    "def event_stream(events, strike_ratio=0):\n",
    "    \"\"\"A generator of random baseball events.\"\"\"\n",
    "    while True:\n",
    "        yield 'K' if (random.random() < strike_ratio ** 3) else random.choice(events)\n",
    "\n",
    "def log(outs, runs, runners, event):\n",
    "    \"\"\"Print a representation of the current state of play.\"\"\"\n",
    "    bases = ''.join('₃²₁'[-b] if b in runners else '.∙.'[-b] for b in (3, 2, 1))\n",
    "    print(f'{outs} outs {runs} runs  {bases} : {event} ({event_names[event]})')\n",
    "    \n",
    "ONBG   = event_stream('2111111EEBBffSSSSSSSFFFFFD334', strike_ratio=7/36) # Our National Ball Game\n",
    "batter = 0 # The batter is a runner who is not yet at first base"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Examples and Tests\n",
    "\n",
    "Let's peek at some random innings:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 outs 0 runs  .∙. : S (out at first)\n",
      "1 outs 0 runs  .∙. : S (out at first)\n",
      "2 outs 0 runs  .∙. : F (fly out)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "inning(ONBG) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 outs 0 runs  .∙.  S (out at first)\n",
      "1 outs 0 runs  .∙.  E (error)\n",
      "1 outs 0 runs  .∙₁  3 (triple)\n",
      "1 outs 1 runs  ₃∙.  2 (double)\n",
      "1 outs 2 runs  .².  F (fly out)\n",
      "2 outs 2 runs  .².  B (base on balls)\n",
      "2 outs 2 runs  .²₁  S (out at first)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "inning(ONBG)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's also test some historic innings. I'll take some of the Red Sox innings from their 2004 playoff series against the Yankees."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 outs 0 runs  .∙.  K (strikeout)\n",
      "1 outs 0 runs  .∙.  2 (double)\n",
      "1 outs 0 runs  .².  f (foul out)\n",
      "2 outs 0 runs  .².  1 (single)\n",
      "2 outs 0 runs  ₃∙₁  2 (double)\n",
      "2 outs 1 runs  ₃².  1 (single)\n",
      "2 outs 2 runs  ₃∙₁  4 (home run)\n",
      "2 outs 5 runs  .∙.  K (strikeout)\n"
     ]
    }
   ],
   "source": [
    "# 7th inning in game 1: 5 runs (Home run by Varitek)\n",
    "# (But not a perfect reproduction, because our simulation doesn't have passed balls.)\n",
    "assert 5 == inning('K2f1214K')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 outs 0 runs  .∙.  S (out at first)\n",
      "1 outs 0 runs  .∙.  S (out at first)\n",
      "2 outs 0 runs  .∙.  2 (double)\n",
      "2 outs 0 runs  .².  1 (single)\n",
      "2 outs 0 runs  ₃∙₁  1 (single)\n",
      "2 outs 1 runs  .²₁  4 (home run)\n",
      "2 outs 4 runs  .∙.  F (fly out)\n"
     ]
    }
   ],
   "source": [
    "# 4th inning in game 6: 4 runs (Homer by Bellhorn)\n",
    "assert 4 == inning('SS2114F')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 outs 0 runs  .∙.  S (out at first)\n",
      "1 outs 0 runs  .∙.  1 (single)\n",
      "1 outs 0 runs  .∙₁  B (base on balls)\n",
      "1 outs 0 runs  .²₁  B (base on balls)\n",
      "1 outs 0 runs  ₃²₁  4 (home run)\n",
      "1 outs 4 runs  .∙.  B (base on balls)\n",
      "1 outs 4 runs  .∙₁  F (fly out)\n",
      "2 outs 4 runs  .∙₁  S (out at first)\n"
     ]
    }
   ],
   "source": [
    "# 2nd inning in game 7: 4 runs (Grand Slam by Damon)\n",
    "assert 4 == inning('S1BB4BFS')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That looks good to me.\n",
    "\n",
    "# Monte Carlo Simulation\n",
    "\n",
    "Now, simulate a hundred thousand innings, and then sample from them to simulate a hundred thousand nine-inning games (for one team), and show histograms of the results, labelled with statistics:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "def simulate(N: int, inning=inning, events=ONBG) -> None:\n",
    "    innings = [inning(events=events, verbose=False) for _ in range(N)]\n",
    "    games   = [sum(random.sample(innings, 9)) for _ in range(N)]\n",
    "    hist(innings, N, 'Runs per inning (for one team)')\n",
    "    hist(games,   N, 'Runs per game (for one team)')\n",
    "    \n",
    "def hist(nums, N, title): \n",
    "    \"\"\"Plot a histogram and show some statistics.\"\"\"\n",
    "    bins = range(min(nums), max(nums) + 2)\n",
    "    plt.hist(nums, ec='black', bins=bins, align='left')\n",
    "    if len(bins) <= 20: plt.xticks(bins[:-1])\n",
    "    plt.xlabel(f'''{title}\\nmean: {mean(nums):.2f}, max: {max(nums)}, σ: {stdev(nums):.2f}, N: {N:,d}''')\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "simulate(N=100000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So, about 13 runs per game (per team). This shows that the dice game is not very realistic with respect to current-day baseball. It is true that games were higher-scoring 130 years ago. Also,  a dice game is more fun when there is a lot of action.\n",
    "\n",
    "# Real Major League Baseball Stats\n",
    "\n",
    "Could I make the game reflect baseball as it is played today? To do so I would need:\n",
    "1. A source of major league baseball (MLB) statistics.\n",
    "2. A way to convert those statistics into the format expected by `event_stream` and `inning`.\n",
    "3. Possibly some modifications to  `inning`, depending on how the conversion goes.\n",
    "\n",
    "[Baseball-reference.com](https://www.baseball-reference.com) has lots of stats, in particular \n",
    "[MLB annual batting stats](https://www.baseball-reference.com/leagues/MLB/bat.shtml) and\n",
    "[fielding stats](https://www.baseball-reference.com/leagues/MLB/field.shtml); I'll use the stats for the complete 2019 season. The batting stats have most of what we need, and the fielding stats show double plays and errors.\n",
    "\n",
    "I start by defining two utility functions that can be useful for any tabular data: `cell_value`, which converts a table cell entry into an `int`, `float`, or `str` as appropriate; and `header_row_dict`, which creates a dict of `{column_name: value}` entries. The function `mlb_convert` then converts this format (a dict keyed by `H/2B/3B/HR` etc.) into the event code format (a string of `'1234...'`). As part of the conversion  I'll add hit-by-pitch (`HBP`) into the \"base on balls\" category, and I'll record all otherwise  unaccounted-for outs under the \"fly out\" (`F`) category (runners do not advance). With this understood, we won't need to change the function `inning` at all. (It is true that `mlb_convert` returns a very long string, equal in length to the number of plate appearances over the whole MLB season. But that takes up less space than storing one photo, so I'm not going to worry about it.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "123.0"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "round(123.0, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "def number(entry: str) -> float:\n",
    "    \"\"\"Convert a string to a number.\"\"\"\n",
    "    return float(entry) if '.' in entry else int(entry)\n",
    "    \n",
    "def header_row_dict(header, row, sep=None) -> dict:\n",
    "    \"\"\"Parse a header and table row into a `{column_name: number,...}` dict.\"\"\"\n",
    "    return dict(zip(header.split(sep), map(number, row.split(sep))))\n",
    "\n",
    "def mlb_convert(stats: dict) -> Counter:\n",
    "    \"\"\"Given baseball stats with MLB names, return a Counter with ONBG names.\"\"\"\n",
    "    events = Counter({\n",
    "        '1': stats['H'] - stats['2B'] - stats['3B'] - stats['HR'],\n",
    "        '2': stats['2B'], '3': stats['3B'], '4': stats['HR'],\n",
    "        'E': stats['E'],  'B': stats['BB'] + stats['HBP'],\n",
    "        'K': stats['SO'], 'D': stats['DP'], 'S': stats['SH'] + stats['SF']})\n",
    "    events['F'] = stats['PA'] - sum(events.values()) # All unaccounted-for outs\n",
    "    return events"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Below I copy-and-paste the data from baseball-reference.com to create the dict `mlb_stats`, convert it to our format with `mlb_convert`, and make one big string of events t create the event generator `mlb_stream`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "mlb_stats = mlb_convert(header_row_dict(\n",
    "    \"Year Tms #Bat BatAge R/G G PA AB R H 2B 3B HR RBI SB CS BB SO BA OBP SLG OPS TB GDP HBP SH SF IBB E DP\",\n",
    "    \"\"\"2019 30 1284 27.9 4.84 4828 185377 165622 23346 41794 8485 783 6735 22358 2261 827 15806 42546 \n",
    "    .252 .323 .435 .758 72050 3441 1968 774 1146 752 2882 3981\"\"\"))\n",
    "\n",
    "mlb_stream = event_stream(''.join(mlb_stats.elements()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can take a look at the stats, and use them to play innings and games:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Counter({'1': 25791,\n",
       "         '2': 8485,\n",
       "         '3': 783,\n",
       "         '4': 6735,\n",
       "         'E': 2882,\n",
       "         'B': 17774,\n",
       "         'K': 42546,\n",
       "         'D': 3981,\n",
       "         'S': 1920,\n",
       "         'F': 74480})"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mlb_stats"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 outs 0 runs  .∙. : F (fly out)\n",
      "1 outs 0 runs  .∙. : 4 (home run)\n",
      "1 outs 1 runs  .∙. : D (double play)\n",
      "2 outs 1 runs  .∙. : F (fly out)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "inning(mlb_stream)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "simulate(events=mlb_stream)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That looks a *lot* more like real baseball. But MLB averaged 4.84 runs per team per game in 2019, and this is over half a run lower. I think we can make some minor changes to the function `inning`&mdash;some \"*standard baseball things*\"&mdash;to make the simulation more realistic. I'm thinking of two changes:\n",
    "- The most common double play eliminates the batter and the runner on first, not the runner closest to home. \n",
    "- On a single, a runner on second often scores. \n",
    "\n",
    "I'll make those two things the case for all double plays and singles."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def inning2(events, verbose=False) -> int:\n",
    "    \"\"\"Simulate a half inning based on events, and return number of runs scored.\"\"\"\n",
    "    outs = runs = 0     # Inning starts with no outs and no runs,\n",
    "    runners = set()     # and with nobody on base\n",
    "    def out(r) -> int: runners.remove(r); return 1\n",
    "    def forced(r) -> bool: return all(b in runners for b in range(r))\n",
    "    def advance(r, e) -> int: \n",
    "        return ((2 if r == 2 else int(e)) if e in '1234' else \n",
    "                (e in 'ESD' or (e == 'B' and forced(r))))    \n",
    "    for e in events:\n",
    "        if verbose: log(outs, runs, runners, e)\n",
    "        runners.add(batter)           # Batter steps up to the plate\n",
    "        if e in 'DSKfF':              \n",
    "            outs += out(batter)       # Batter is out\n",
    "        if e == 'D' and 1 in runners and outs < 3: \n",
    "            outs += out(1)            # Double play: runner on first out\n",
    "        if outs == 3:                 # If inning is over: return runs scored\n",
    "            return runs \n",
    "        runners = {r + advance(r, e) for r in runners} # Runners advance\n",
    "        scored  = {r for r in runners if r >= 4}       # Runners who scored\n",
    "        runners = runners - scored                     # Remove runners who scored\n",
    "        runs   += len(scored)                          # Tally runs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We show the difference with two examples. First, a triple/walk/double-play sequence scores a run under `inning2` but not `inning`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 outs 0 runs  .∙. : 3 (triple)\n",
      "0 outs 0 runs  ₃∙. : B (base on balls)\n",
      "0 outs 0 runs  ₃∙₁ : D (double play)\n",
      "2 outs 1 runs  .∙. : K (strikeout)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "inning2('3BDK', True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 outs 0 runs  .∙. : 3 (triple)\n",
      "0 outs 0 runs  ₃∙. : B (base on balls)\n",
      "0 outs 0 runs  ₃∙₁ : D (double play)\n",
      "2 outs 0 runs  .². : K (strikeout)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "inning('3BDK', True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Second, a double/single sequence scores a run under `inning2` but not `inning`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 outs 0 runs  .∙. : 2 (double)\n",
      "0 outs 0 runs  .². : 1 (single)\n",
      "0 outs 1 runs  .∙₁ : F (fly out)\n",
      "1 outs 1 runs  .∙₁ : F (fly out)\n",
      "2 outs 1 runs  .∙₁ : F (fly out)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "inning2('21FFF', True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 outs 0 runs  .∙. : 2 (double)\n",
      "0 outs 0 runs  .². : 1 (single)\n",
      "0 outs 0 runs  ₃∙₁ : F (fly out)\n",
      "1 outs 0 runs  ₃∙₁ : F (fly out)\n",
      "2 outs 0 runs  ₃∙₁ : F (fly out)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "inning('21FFF', True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can simulate again and note any differences:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "simulate(events=mlb_stream, inning=inning2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There is a slight increase in the number of runs scored, but we're still a half a run per game below the actual MLB figure. I think that the main reason is that in our simulation, every hitter is average. Real MLB lineups cluster their best hitters together, usually in the 1-4 slot of the lineup, so when one of them gets a hit, another is more likely than average to bat them in. Also, some teams have a higher overall batting average, and thus are more likely to bat their teammates in."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Opportunities for Improvement\n",
    "\n",
    "There are many problems with the simulation code as it is. For example:\n",
    "\n",
    "- It assumes all pitchers and defense are equal. They're not.\n",
    "- It assumes all batters are equal. They're not. \n",
    "- It assumes all hits are the same (runners always advance the same number of bases). They're not.\n",
    "- There's only one type of double play (batter and runner on first out) and no triple play.\n",
    "- It ignores stolen bases, pickoffs, passed balls, wild pitches, runners taking extra bases, and runners being out on attempted steals, extra bases, or sacrifices.\n",
    "- There is no strategy (offense and defense behave the same, regardless of the situation).\n",
    "- It assumes both teams bat for 9 innings. But if the home team is ahead at the bottom of the 9th, they do not bat, and if the score is tied: extra innings.\n",
    "- With two outs, or with no runners on base, there can be no sacrifice or double play; those types of events would just be regular outs. The stats say that a double play should occur in 3981 out of 185377 at bats, or about 2% of the time. In our simulation the `D` event code would come up that often, but perhaps only half the time there would be a runner and less than two outs, so we would only actually get a double play maybe 1% of the time.\n",
    "\n",
    "What can you do to make the simulation better?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Batting .400 in a Short Season: A Non-Simulation\n",
    "\n",
    "Here is a different baseball puzzle. The [538 Riddler for 17 July, 2020](https://fivethirtyeight.com/features/can-the-hare-beat-the-tortoise/) asks: what is the likelihood of a baseball player batting .400 in a pandemic-shortened 60 game season? How does that compare to a full (162 game) season? Note that no player  has batted .400 since Ted Williams in 1941.) Assume a player has a probability of .350 of getting a hit in each at bat, independent of any other at bat, and that a player gets exactly 4 at bats in each game.\n",
    "\n",
    "We could simulate this easily enough. But it is easy, more accurate, and less computation to compute the exact answer. To bat .400 with 4 at bats in each of 60 games, you need to get at least .400 × 4 × 60 = 96 hits in 240 at bats. What's the probability of getting at least *k* hits in *n* at bats, given that the probability of getting a hit in each at bat is *p*? There are three cases:\n",
    "- If *k* > *n* it is impossible.\n",
    "- If *k* ≤ 0 it is certain.\n",
    "- Otherwise: \n",
    "  - With probability *p* you get a hit, and then need at least *k* - 1 hits out of *n* - 1 at bats.\n",
    "  - With probability (1 - *p*) you are out and then need at least *k* hits out of *n* - 1 at bats.\n",
    "  \n",
    "We can code that directly:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "import functools\n",
    "\n",
    "@functools.lru_cache(None)\n",
    "def at_least(k, n, p):\n",
    "    \"\"\"The probability of getting at least k out of n hits, when each hit has probability p.\"\"\"\n",
    "    return (0.0       if k > n else\n",
    "            1.0       if k <= 0 else\n",
    "            p         * at_least(k - 1, n - 1, p)\n",
    "            + (1 - p) * at_least(k,     n - 1, p))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.06083862769698295"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n1 = 60 * 4 # total number of at bats in a short season\n",
    "\n",
    "at_least(.400 * n1, n1, 0.350)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.003789921663584505"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n2 = 162 * 4 # total number of at bats in a full season\n",
    "\n",
    "at_least(.400 * n2, n2, 0.350)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We see that a .350 hitter has a 6% chance of  batting .400 in a short season, but less than a 0.4% chance in a full season. \n",
    "\n",
    "Here are some batting leaders from years past, chosen to span the range from .330 to .420; I'll make a table of their chances to hit .400 in both a 60 game and 162 game season:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Name       BA  60G     162G\n",
      "Cabrera  .330   1%    0.01%\n",
      "Holliday .340   3%    0.07%\n",
      "Betts    .346   5%    0.19%\n",
      "Suzuki   .350   6%    0.38%\n",
      "Bonds    .362  12%    2.14%\n",
      "Nomar    .372  20%    6.75%\n",
      "DiMaggio .381  29%   15.38%\n",
      "Brett    .390  40%   29.18%\n",
      "Hornsby  .401  54%   51.01%\n",
      "Williams .406  60%   61.21%\n",
      "Cobb     .419  75%   83.05%\n"
     ]
    }
   ],
   "source": [
    "players = dict(Cabrera=330, Holliday=340, Betts=346, Suzuki=350,\n",
    "    Bonds=362, Nomar=372, DiMaggio=381, Brett=390, Hornsby=401, \n",
    "    Williams=406, Cobb=419)\n",
    "\n",
    "print('Name       BA  60G     162G')\n",
    "for name in players:\n",
    "    pct1 = at_least(.400 * n1, n1, players[name] / 1000)\n",
    "    pct2 = at_least(.400 * n2, n2, players[name] / 1000)\n",
    "    print(f'{name:8} .{players[name]:3}  {pct1:3.0%}   {pct2:6.2%}')"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.15"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
